home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume89 / unix / shel303a.2 < prev    next >
Text File  |  1989-05-18  |  58KB  |  2,239 lines
  1. Path: xanth!ames!apple!sun!swap!page
  2. From: page%swap@Sun.COM (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v89i150:  shell - csh-like shell v3.03a, Part02/02
  5. Message-ID: <105699@sun.Eng.Sun.COM>
  6. Date: 18 May 89 19:29:01 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 2228
  9. Approved: page@sun.com
  10.  
  11. Submitted-by: PERUGIA@ICNUCEVM.Bitnet (Cesare Dieni)
  12. Posting-number: Volume 89, Issue 150
  13. Archive-name: unix/shell303a.2
  14.  
  15. # This is a shell archive.
  16. # Remove anything above and including the cut line.
  17. # Then run the rest of the file through 'sh'.
  18. # Unpacked files will be owned by you and have default permissions.
  19. #----cut here-----cut here-----cut here-----cut here----#
  20. #!/bin/sh
  21. # shar: SHell ARchive
  22. # Run the following text through 'sh' to create:
  23. #    globals.c
  24. #    main.c
  25. #    makefile
  26. #    rawconsole.c
  27. #    run.c
  28. #    set.c
  29. #    shell.h
  30. #    shellfunctions.h
  31. #    sub.c
  32. # This is archive 2 of a 2-part kit.
  33. # This archive created: Thu May 18 12:17:54 1989
  34. echo "extracting globals.c"
  35. sed 's/^X//' << \SHAR_EOF > globals.c
  36. X
  37. X/*
  38. X * GLOBALS.C
  39. X *
  40. X * (c)1986 Matthew Dillon     9 October 1986
  41. X *
  42. X * Version 2.07M by Steve Drew 10-Sep-87
  43. X *
  44. X *    Most global variables.
  45. X *
  46. X * Version 3.03A by Carlo Borreo & Cesare Dieni 12-May-89
  47. X *
  48. X */
  49. X
  50. Xchar *v_titlebar="_titlebar";    /* Window title                */
  51. Xchar *v_prompt    ="_prompt";    /* your prompt (ascii command)        */
  52. Xchar *v_hist    ="_history";    /* set history depth (value)        */
  53. Xchar *v_histnum    ="_histnum";    /* set history numbering var        */
  54. Xchar *v_debug    ="_debug";    /* set debug mode            */
  55. Xchar *v_verbose    ="_verbose";    /* set verbose for source files        */
  56. Xchar *v_stat    ="_maxerr";    /* worst return value to date        */
  57. Xchar *v_lasterr    ="_lasterr";    /* return value from last comm.        */
  58. Xchar *v_cwd    ="_cwd";    /* current directory            */
  59. Xchar *v_except    ="_except";    /* "nnn;command"            */
  60. Xchar *v_passed    ="_passed";    /* passed arguments to source file    */
  61. Xchar *v_path    ="_path";    /* search path for external commands    */
  62. Xchar *v_gotofwd    ="_gtf";    /* set name for fwd goto name        */
  63. X
  64. Xstruct HIST *H_head, *H_tail;    /* HISTORY lists */
  65. X
  66. Xstruct PERROR Perror[]= {    /* error code->string */
  67. X    103,    "Insufficient free storage",
  68. X    105,    "Task table full",
  69. X    120,    "Argument line invalid or too long",
  70. X    121,    "File is not an object module",
  71. X    122,    "Invalid resident library during load",
  72. X    201,    "No default directory",
  73. X    202,    "Object in use",
  74. X    203,    "Object already exists",
  75. X    204,    "Directory not found",
  76. X    205,    "Object not found",
  77. X    206,    "Bad stream name",
  78. X    207,    "Object too large",
  79. X    209,    "Action not known",
  80. X    210,    "Invalid stream component name",
  81. X    211,    "Invalid object lock",
  82. X    212,    "Object not of required type",
  83. X    213,    "Disk not validated",
  84. X    214,    "Disk write protected",
  85. X    215,    "Rename across devices",
  86. X    216,    "Directory not empty",
  87. X    217,    "Too many levels",
  88. X    218,    "Device not mounted",
  89. X    219,    "Seek error",
  90. X    220,    "Comment too long",
  91. X    221,    "Disk full",
  92. X    222,    "File delete protected",
  93. X    223,    "File write protected",
  94. X    224,    "File read protected",
  95. X    225,    "Not a DOS disk",
  96. X    226,    "No disk",
  97. X
  98. X /* custom error messages */
  99. X
  100. X    500,    "Bad arguments",
  101. X    501,    "Label not found",
  102. X    502,    "Must be within source file",
  103. X    503,    "Syntax Error",
  104. X    504,    "Redirection error",
  105. X    505,    "Pipe error",
  106. X    506,    "Too many arguments",
  107. X    507,    "Destination not a directory",
  108. X    508,    "Cannot mv a filesystem",
  109. X    509,    "Error in command name",
  110. X    510,    "Bad drive name",
  111. X    511,    "Illegal number",
  112. X    0,    NULL
  113. X};
  114. X
  115. Xchar *av[MAXAV];        /* Internal argument list        */
  116. Xlong Src_base[MAXSRC];        /* file pointers for source files    */
  117. Xlong Src_pos[MAXSRC];        /* seek position storage for same    */
  118. Xchar If_base[MAXIF];        /* If/Else stack for conditionals    */
  119. Xint H_len, H_tail_base;        /* History associated stuff        */
  120. Xint H_stack;            /* AddHistory disable stack        */
  121. Xint E_stack;            /* Exception disable stack        */
  122. Xint Src_stack, If_stack;    /* Stack Indexes            */
  123. Xint forward_goto;        /* Flag for searching for foward lables    */
  124. Xint ac;                /* Internal argc            */
  125. Xint debug;            /* Debug mode                */
  126. Xint disable;            /* Disable com. execution (conditionals)*/
  127. Xint Verbose;            /* Verbose mode for source files    */
  128. Xint Lastresult;            /* Last return code            */
  129. Xint Exec_abortline;        /* flag to abort rest of line        */
  130. Xint Quit;            /* Quit flag                */
  131. Xlong Cout, Cin;            /* Current input and output file handles*/
  132. Xlong Cout_append;        /* append flag for Cout            */
  133. Xchar *Cin_name, *Cout_name;    /* redirection input/output name or NULL*/
  134. Xchar *Pipe1, *Pipe2;        /* the two pipe temp. files        */
  135. Xstruct Process *Myprocess;
  136. Xstruct CommandLineInterface *Mycli;
  137. Xint S_histlen = 20;        /* Max # history entries        */
  138. Xunsigned int options;
  139. SHAR_EOF
  140. echo "extracting main.c"
  141. sed 's/^X//' << \SHAR_EOF > main.c
  142. X/*
  143. X * MAIN.C
  144. X *
  145. X * Matthew Dillon, 24 Feb 1986
  146. X * (c)1986 Matthew Dillon     9 October 1986
  147. X *
  148. X * Version 2.07M by Steve Drew 10-Sep-87
  149. X *
  150. X * Version 3.03A by Carlo Borreo & Cesare Dieni 12-May-89
  151. X *
  152. X */
  153. X
  154. Xchar *shellctr="CshCounter";
  155. X
  156. Xextern char *v_titlebar, *v_prompt, *v_hist, *v_lasterr, *v_path;
  157. X
  158. Xint aux; /* for use with aux: driver */
  159. Xchar *oldtitle;
  160. Xchar trueprompt[100];
  161. Xchar Inline[260];
  162. Xstruct IntuitionBase *IntuitionBase;
  163. Xstruct Window *w;
  164. Xstruct ArpBase *ArpBase;
  165. X
  166. Xmain(argc, argv)
  167. Xregister char *argv[];
  168. X{
  169. X#if RAW_CONSOLE
  170. X    char *rawgets();
  171. X#endif
  172. X
  173. Xregister unsigned int i;
  174. Xextern int Enable_Abort;
  175. Xchar buf[10];
  176. X
  177. XArpBase=(struct ArpBase *)OpenLibrary("arp.library",34L);
  178. Xif (ArpBase==NULL) { printf("No arp library\n"); exit(0); }
  179. X
  180. XForbid();
  181. Xi=Errno=0;
  182. Xif (Getenv(shellctr,buf,10L)) {
  183. X    i=(int)(long)Atol(buf);
  184. X    if (Errno) i=0;
  185. X    }
  186. Xsprintf(buf,"%d",i+1);
  187. XSetenv(shellctr,buf);
  188. XPermit();
  189. X
  190. XIntuitionBase=(struct IntuitionBase *)ArpBase->IntuiBase;
  191. X
  192. Xinit();
  193. X
  194. Xsprintf(buf,"%ld",Myprocess->pr_TaskNum);
  195. Xset_var(LEVEL_SET, "_clinumber", buf);
  196. X
  197. Xoldtitle=(char *)(w->Title);
  198. X
  199. Xset_var(LEVEL_SET, v_titlebar, "CShell V3.03A");
  200. Xset_var(LEVEL_SET, v_prompt,
  201. X    (IsInteractive(Input())) ? "\23337m%p> \2330m" : "");
  202. Xset_var(LEVEL_SET, v_hist, "20");
  203. Xset_var(LEVEL_SET, v_lasterr, "0");
  204. Xset_var(LEVEL_SET, v_path, "RAM:,RAM:c/,df0:c/,df1:c/,sys:system/");
  205. Xset_var(LEVEL_SET, "_insert", "1");
  206. Xset_var(LEVEL_SET, "f1", "cdir df0:\15");
  207. Xset_var(LEVEL_SET, "F1", "cdir df1:\15");
  208. Xset_var(LEVEL_SET, "f3", "cdir RAM:\15");
  209. Xset_var(LEVEL_SET, "F3", "cdir vd0:\15");
  210. Xset_var(LEVEL_SET, "f4", "cd df0:\15");
  211. Xset_var(LEVEL_SET, "F4", "cd df1:\15");
  212. Xset_var(LEVEL_SET, "f5", "cls; ls\15");
  213. Xset_var(LEVEL_SET, "F5", "cdir ");
  214. Xset_var(LEVEL_SET, "f6", "lc\15");
  215. Xset_var(LEVEL_SET, "f7", "info\15");
  216. Xset_var(LEVEL_SET, "F7", "assign \15");
  217. Xset_var(LEVEL_SET, "f8", "window -lf\15");
  218. Xset_var(LEVEL_SET, "F8", "window -sb\15");
  219. Xset_var(LEVEL_SET, "f10", "cls\15");
  220. Xset_var(LEVEL_SET, "F10", "exit\15");
  221. Xset_var(LEVEL_ALIAS, "cls", "echo -n ^l");
  222. Xset_var(LEVEL_ALIAS, "lc", "ls -s");
  223. Xset_var(LEVEL_ALIAS, "kr", "rm -r RAM:* >NIL:");
  224. Xset_var(LEVEL_ALIAS, "cdir", "%q cd $q; cls; dir");
  225. Xset_var(LEVEL_ALIAS, "exit", "endcli;quit");
  226. Xset_var(LEVEL_ALIAS, "lp", "cat >PRT:");
  227. Xseterr();
  228. Xdo_pwd(NULL); /* set $_cwd */
  229. XEnable_Abort = 0;
  230. X
  231. Xif (exists(av[1] = "S:.login")) {
  232. X    strcpy(Inline, "source S:.login");
  233. X    do_source (Inline);
  234. X    }
  235. X
  236. Xfor (i = 1; i < argc; ++i) {
  237. X    if (!strcmp(argv[i],"-c")) {
  238. X        Inline[0] = ' ';
  239. X        Inline[1] = '\0';
  240. X        while (++i < argc)
  241. X            { strcat(Inline,argv[i]); strcat(Inline," "); }
  242. X        exec_command(Inline);
  243. X        main_exit(Lastresult);
  244. X        }
  245. X    if (!strcmp(argv[i],"-a")) { aux = 1; continue; }
  246. X    sprintf (Inline, "source %s",argv[i]);
  247. X    av[1] = argv[i];
  248. X    do_source (Inline);
  249. X    }
  250. Xfor (;;) {
  251. X   if (breakcheck())
  252. X    while (WaitForChar(Input(), 100L) || stdin->_bp < stdin->_bend)
  253. X        gets(Inline);
  254. X   clearerr(stdin);  /* prevent acidental quit */
  255. X#if RAW_CONSOLE
  256. X   if (Quit || !rawgets(Inline, disable ? "_ " : trueprompt)) main_exit(0);
  257. X#else
  258. X   printf("%s", disable ? "_ " : trueprompt);
  259. X   fflush(stdout);
  260. X   if (Quit || !gets(Inline)) main_exit(0);
  261. X#endif
  262. X   breakreset();
  263. X   if (*Inline) exec_command(Inline);
  264. X   }
  265. X}
  266. X
  267. Xmain_exit(n)
  268. X{
  269. Xregister unsigned short i;
  270. Xchar buf[10];
  271. X
  272. XGetenv(shellctr,buf,10L);
  273. Xi=(int)Atol(buf);
  274. Xsprintf(buf,"%d",i-1);
  275. XSetenv(shellctr,buf);
  276. XSetWindowTitles(w,oldtitle,-1L);
  277. Xfor (i=1; i<MAXMYFILES; i++) myclose(i);
  278. XArpExit(0L,0L);            /* Intuition need not to be closed */
  279. X}
  280. X
  281. Xinit()
  282. X{
  283. Xstatic char pipe1[32], pipe2[32];
  284. Xstruct Window *getwindow();
  285. X
  286. Xstdin->_flags    |= 0x80;    /* make sure we're set as a tty */
  287. Xstdout->_flags    |= 0x80;    /* in case of redirection in .login */
  288. XClose(_devtab[2].fd);
  289. X_devtab[2].mode |= O_STDIO;
  290. X_devtab[2].fd = _devtab[1].fd;    /* set stderr to Output() otherwise */
  291. X                /* don't work with aux driver */
  292. XMyprocess = (struct Process *)FindTask(0L);
  293. XMycli=(struct CommandLineInterface *)((long)Myprocess->pr_CLI << 2);
  294. Xw=getwindow();
  295. XPipe1 = pipe1;
  296. XPipe2 = pipe2;
  297. Xsprintf(pipe1, "ram:pipe1_%ld", Myprocess);
  298. Xsprintf(pipe2, "ram:pipe2_%ld", Myprocess);
  299. X}
  300. X
  301. Xbreakcheck()
  302. X{
  303. Xreturn (int)(SetSignal(0L,0L) & SIGBREAKF_CTRL_C);
  304. X}
  305. X
  306. Xbreakreset()
  307. X{
  308. XSetSignal(0L, SIGBREAKF_CTRL_C);
  309. X}
  310. X
  311. Xdobreak()
  312. X{
  313. Xif (breakcheck()) { printf("^C\n"); return(1); }
  314. Xreturn(0);
  315. X}
  316. X
  317. X/* this routine causes manx to use this Chk_Abort() rather than it's own */
  318. X/* otherwise it resets our ^C when doing any I/O (even when Enable_Abort */
  319. X/* is zero).  Since we want to check for our own ^C's             */
  320. X
  321. XChk_Abort()
  322. X{
  323. Xreturn(0);
  324. X}
  325. X
  326. X_wb_parse()
  327. X{
  328. X}
  329. X
  330. Xdo_howmany()
  331. X{
  332. Xchar buf[10];
  333. X
  334. XGetenv(shellctr, buf, 10L);
  335. Xprintf("Shell(s) running: %s\n",buf);
  336. X}
  337. X
  338. Xstruct Window *getwindow()
  339. X{
  340. Xstruct InfoData *infodata;
  341. Xstruct Window *win;
  342. Xlong args[8];
  343. X
  344. Xinfodata=AllocMem((long)sizeof(struct InfoData),MEMF_CLEAR | MEMF_PUBLIC);
  345. Xargs[0]=(long)infodata >> 2;
  346. XSendPacket(ACTION_DISK_INFO,args,Myprocess->pr_ConsoleTask);
  347. Xwin=(struct Window *)infodata->id_VolumeNode;
  348. XFreeMem(infodata,(long)sizeof(struct InfoData));
  349. Xreturn win;
  350. X}
  351. SHAR_EOF
  352. echo "extracting makefile"
  353. sed 's/^X//' << \SHAR_EOF > makefile
  354. X######################################################################
  355. X#
  356. X# Makefile to build Shell 3.02A
  357. X# by Carlo Borreo & Cesare Dieni 20-Dec-88
  358. X#
  359. X######################################################################
  360. X
  361. XOBJS    = run.o main.o comm1.o comm2.o comm3.o execom.o set.o sub.o \
  362. X      globals.o rawconsole.o
  363. X
  364. XINCL    = shell.h
  365. X
  366. XShell   : Shell.syms $(OBJS)
  367. X    ln  +q -m -o Shell $(OBJS) -la -lc
  368. X
  369. XShell.syms : $(INCL)
  370. X    cc +HShell.syms shell.h
  371. X
  372. Xrawconsole.o : rawconsole.c $(INCL)
  373. X    cc +IShell.syms rawconsole.c
  374. X
  375. Xrun.o   : run.c $(INCL)
  376. X    cc +IShell.syms run.c
  377. X
  378. Xmain.o  : main.c $(INCL)
  379. X    cc +IShell.syms main.c
  380. X
  381. Xcomm1.o : comm1.c $(INCL)
  382. X    cc +IShell.syms comm1.c
  383. X
  384. Xcomm2.o : comm2.c $(INCL)
  385. X    cc +IShell.syms comm2.c
  386. X
  387. Xcomm3.o : comm3.c $(INCL)
  388. X    cc +IShell.syms comm3.c
  389. X
  390. Xset.o   : set.c $(INCL)
  391. X    cc +IShell.syms set.c
  392. X
  393. Xsub.o   : sub.c $(INCL)
  394. X    cc +IShell.syms sub.c
  395. X
  396. Xglobals.o : globals.c $(INCL)
  397. X    cc +IShell.syms globals.c
  398. X
  399. Xexecom.o : execom.c $(INCL)
  400. X    cc +IShell.syms execom.c
  401. SHAR_EOF
  402. echo "extracting rawconsole.c"
  403. sed 's/^X//' << \SHAR_EOF > rawconsole.c
  404. X/*
  405. X * RawConsole.c
  406. X *
  407. X * Shell 2.07M  17-Jun-87
  408. X * console handling, command line editing support for Shell
  409. X * using new console packets from 1.2.
  410. X * Written by Steve Drew. (c) 14-Oct-86.
  411. X * 16-Dec-86 Slight mods to rawgets() for Disktrashing.
  412. X *
  413. X * Version 3.03A by Carlo Borreo & Cesare Dieni 12-May-89
  414. X *
  415. X */
  416. X
  417. X#if RAW_CONSOLE
  418. X
  419. Xchar *tyahdptr;
  420. X
  421. Xmyget()
  422. X{
  423. Xif (*tyahdptr) return *tyahdptr++;
  424. Xreturn getchar();
  425. X}
  426. X
  427. Xextern int aux; /* for use with aux: */
  428. X
  429. X#define SETRAW setrawcon(-1L);
  430. X#define SETCON setrawcon(0L);
  431. X
  432. Xint width;
  433. X
  434. Xnewwidth()
  435. X{
  436. Xextern struct Window *w;
  437. X
  438. Xwidth=(w->Width- (w->BorderLeft + w->BorderRight)) / w->RPort->TxWidth;
  439. X}
  440. X
  441. Xchar *rawgets(line,prompt)
  442. Xchar *line, *prompt;
  443. X{
  444. Xchar *get_var();
  445. Xchar *gets();
  446. Xregister int n, pl;
  447. Xregister int max, i;
  448. Xunsigned char c1,c2,c3;
  449. Xchar fkeys[5];
  450. Xchar *s;
  451. Xchar *ps;
  452. Xchar typeahd[256];
  453. Xint fkey, savn;
  454. Xint insert = 1;
  455. Xint recall = -1;
  456. Xstruct HIST *hist;
  457. X
  458. Xnewwidth();
  459. X
  460. Xif (aux) {
  461. X    printf("%s",prompt);
  462. X    fflush(stdout);
  463. X    }
  464. Xif (!IsInteractive(Input()) || aux ) return(gets(line));
  465. Xif (WaitForChar((long)Input(), 100L) ||   /* don't switch to 1L ...*/
  466. X        stdin->_bp < stdin->_bend) {     /* else causes read err's*/
  467. X    gets(line);
  468. X    return(line);
  469. X    }
  470. XSETRAW;
  471. Xprintf("\015%s\2336n",prompt);
  472. Xsavn = pl = n = 0;
  473. Xtyahdptr = typeahd;
  474. Xwhile((typeahd[n]=getchar()) != 'R') {
  475. X    if ((unsigned char)typeahd[n] == 155) savn = n;
  476. X    n++;
  477. X    }
  478. X    /* typeahd now contains possible type a head chars
  479. X       followed by <CSI> cursor position report.
  480. X    */
  481. Xtypeahd[savn]  = '\0';
  482. Xif (typeahd[n-2] != ';') pl = (typeahd[n-2] - 48) * 10;
  483. Xpl += typeahd[n-1] - 49;
  484. Xps = line + pl;
  485. Xline[max = i = pl] = '\0';
  486. X
  487. Xif (s = get_var (LEVEL_SET, "_insert")) insert = atoi(s) ? 1 : 0;
  488. X
  489. Xwhile( (c1 = myget()) != 255) {
  490. X        switch(c1) {
  491. X            case 155:
  492. X                 c2 = myget();
  493. X                 switch(c2) {
  494. X                     case 'A':                  /* up arrow   */
  495. X                        n = ++recall;
  496. X                     case 'B':                  /* down arrow */
  497. X                        line[pl] = '\0';
  498. X                        if (recall >= 0 || c2 == 'A') {
  499. X                            if (c2 == 'B') n = --recall;
  500. X                            if (recall >= 0) {
  501. X                                for(hist = H_head; hist && n--;
  502. X                                    hist = hist->next);
  503. X                                if (hist) strcpy(&line[pl],hist->line);
  504. X                                else recall = H_len;
  505. X                            }
  506. X                        }
  507. X                        if (i != pl)
  508. X                            printf("\233%dD",i);
  509. X                        printf("\015\233J%s%s",prompt,ps);
  510. X                        i = max = strlen(ps) + pl;
  511. X                        break;
  512. X                     case 'C':                  /* right arrow*/
  513. X                        if (i < max) {
  514. X                            i++;
  515. X                            printf("\233C");
  516. X                        }
  517. X                        break;
  518. X                     case 'D':                  /* left arrow */
  519. X                        if (i > pl) {
  520. X                            i--;
  521. X                            printf("\233D");
  522. X                        }
  523. X                        break;
  524. X                     case 'T':           /* shift-up   */
  525. X                       n = recall = H_len-1;
  526. X                     case 'S':           /* shift-down */
  527. X                       line[pl] = '\0';
  528. X                       if (c2 == 'S') {
  529. X                           n = recall = 0;
  530. X                           if (H_head) strcpy(&line[pl], H_head->line);
  531. X                       }
  532. X                       else if (H_tail) strcpy(&line[pl], H_tail->line);
  533. X                       printf("\015\233J%s%s", prompt, ps);
  534. X                       i = max = strlen(ps) + pl;
  535. X                       break;
  536. X                    case ' ':                   /* shift -> <-*/
  537. X                        c3 = myget();
  538. X                                     switch(c3) {
  539. X                    case('@'):      /* shift ->   */
  540. X                        while (ps[i-pl-1] == ' ' && i<max) {
  541. X                          i++;
  542. X                          printf("\233C");
  543. X                }
  544. X                        while (ps[i-pl-1] != ' ' && i<max) {
  545. X                          i++;
  546. X                    printf("\233C");
  547. X                       }
  548. X                        break;
  549. X                    case('A'):      /* shift <-   */
  550. X                        while (ps[i-pl-1] == ' ' && i>pl) {
  551. X                            i--;
  552. X                            printf("\233D");
  553. X                        }
  554. X                        while (ps[i-pl-1] != ' ' && i>pl) {
  555. X                            i--;
  556. X                            printf("\233D");
  557. X                        }
  558. X                        break;
  559. X                        default:
  560. X                        break;
  561. X                    }
  562. X                        break;
  563. X                    default:
  564. X                        c3 = myget();
  565. X                        if (c3 == '~') {
  566. X                            fkey = c2;
  567. X                            fkeys[0] = 'f';
  568. X                            if (c2 == '?') {
  569. X                                strcpy(ps,"help");
  570. X                                goto done;
  571. X                            }
  572. X                        }
  573. X                        else if (myget() != '~') { /* window was resized */
  574. X                            while(myget() != '|');
  575. X                            newwidth();
  576. X                            break;
  577. X                        }
  578. X                        else {
  579. X                            fkey = c3;
  580. X                            fkeys[0] = 'F';
  581. X                        }
  582. X                        sprintf(fkeys+1,"%d",fkey - 47);
  583. X                        if (s = get_var(LEVEL_SET, fkeys))
  584. X                                tyahdptr = strcpy(typeahd,s);
  585. X                        break;
  586. X                    }
  587. X                break;
  588. X            case 8:
  589. X                if (i > pl) {
  590. X                    i--;
  591. X                    printf("\010");
  592. X                }
  593. X                else break;
  594. X            case 127:
  595. X                if (i < max) {
  596. X                    int j,t,l = 0;
  597. X                    movmem(&line[i+1],&line[i],max-i);
  598. X                    --max;
  599. X                    printf("\233P");
  600. X                    j = width - i % width - 1;   /* amount to end     */
  601. X                    t = max/width - i/width;     /* no of lines       */
  602. X                    for(n = 0; n < t; n++) {
  603. X                        l += j;                  /* no. of char moved */
  604. X                        if (j) printf("\233%dC",j); /* goto eol       */
  605. X                        printf("%c\233P",line[width*(i/width+n+1)-1]);
  606. X                        j = width-1;
  607. X                    }
  608. X                    if (t)
  609. X                    printf("\233%dD",l+t);   /* get back */
  610. X                }
  611. X                break;
  612. X            case 18:
  613. X                n = i/width;
  614. X                if (n) printf("\233%dF",n);
  615. X                printf("\015\233J%s%s",prompt,ps);
  616. X                i = max;
  617. X                break;
  618. X            case 27:
  619. X                break;
  620. X            case 1:
  621. X                insert ^= 1;
  622. X                break;
  623. X            case 21:
  624. X            case 24:
  625. X            case 26:
  626. X                if (i>pl) printf("\233%dD",i-pl);
  627. X                i = pl;
  628. X                if (c1 == 26) break;
  629. X            case 11:        /* ^K */
  630. X                printf("\233J");
  631. X                max = i;
  632. X                line[i] = '\0';
  633. X                break;
  634. X            case 28:        /* ^\ */
  635. X                SETCON;
  636. X                return(NULL);
  637. X            case 5:
  638. X                if (i!=max) printf("\233%dC",max - i);
  639. X                i = max;
  640. X                break;
  641. X            case 10:
  642. X            case 13:
  643. X                line[max] = '\0';
  644. Xdone:           printf("\233%dC\n",max - i);
  645. X
  646. X                SETCON;
  647. X                strcpy(line, ps);
  648. X                return(line);
  649. X            default:
  650. X                c1 &= 0x7f;
  651. X                if (c1 == 9) c1 = 32;
  652. X                if (c1 > 31 & i < 256) {
  653. X                    if (i < max && insert) {
  654. X                        int j,t,l = 0;
  655. X                        movmem(&line[i], &line[i+1], max - i);
  656. X                        printf("\233@%c",c1);
  657. X                        t = max/width - i/width;
  658. X                        j = width - i % width - 1;
  659. X                        for(n = 0; n < t; n++) {
  660. X                            l += j;
  661. X                            if (j) printf("\233%dC",j);
  662. X                            printf("\233@%c",line[width*(i/width+n+1)]);
  663. X                            j = width-1;
  664. X                        }
  665. X                        if (t) printf("\233%dD",l + t);
  666. X                        ++max;
  667. X                    }
  668. X                    else {
  669. X                        if(i == pl && max == i) printf("\015%s%s",prompt,ps);
  670. X                        putchar(c1);
  671. X                    }
  672. X                    line[i++] = c1;
  673. X                    if (max < i) max = i;
  674. X                    line[max] = '\0';
  675. X                }
  676. X        }
  677. X    }
  678. XSETCON;
  679. Xreturn(NULL);
  680. X}
  681. X
  682. Xsetrawcon(flag) /* -1L=RAW:, 0L=CON: */
  683. Xlong flag;
  684. X{
  685. Xlong packargs[8];
  686. X
  687. Xpackargs[0]=flag;
  688. XSendPacket(994L, packargs, Myprocess->pr_ConsoleTask);
  689. X}
  690. X
  691. X#endif
  692. SHAR_EOF
  693. echo "extracting run.c"
  694. sed 's/^X//' << \SHAR_EOF > run.c
  695. X
  696. X/*
  697. X * RUN.C
  698. X *
  699. X * (c)1986 Matthew Dillon     9 October 1986
  700. X *
  701. X *    RUN   handles running of external commands.
  702. X *
  703. X * Version 2.07M by Steve Drew 10-Sep-87
  704. X *
  705. X * Version 3.03A by Carlo Borreo & Cesare Dieni 12-May-89
  706. X *
  707. X */
  708. X
  709. Xextern char *v_path;
  710. Xchar *FindIt();
  711. X
  712. Xdo_run(str)
  713. Xchar *str;
  714. X{
  715. Xint i, len, retcode;
  716. Xchar buf[200]; /* enough space for 100 char cmd name + path stuff */
  717. Xchar *path;
  718. X
  719. Xchar *p = av[0];
  720. Xchar **args = av+1;
  721. X
  722. Xwhile(*p++) *p &= 0x7F;      /* allow "com mand" */
  723. X
  724. Xwhile(*args) {                /* if any arg contains a space then */
  725. X    if (index(*args,' ')) {        /* surround with quotes, since must */
  726. X    i = strlen(*args);        /* of specified via "arg u ment" on */
  727. X    movmem(*args,(*args)+1,i);    /* original command line.        */
  728. X    args[0][0] = args[0][i+1] = '\"';    /* mpush in execom.c has    */
  729. X    args[0][i+2] = '\0';        /* allowed for these 2 extra bytes. */
  730. X    }
  731. X    ++args;
  732. X    }
  733. Xif ((len = strlen(av[0])) > 100) { ierror(NULL,509); return -1; }
  734. Xif (path = FindIt(av[0],"",buf)) retcode = myfexecv(path, av);
  735. Xelse {
  736. X    Myprocess->pr_WindowPtr = (APTR)(-1);
  737. X    /*
  738. X     * manx's fexecv code only allows us 38
  739. X     * chars for command name.
  740. X     */
  741. X    if (len > 37) av[0][37] = '\0';
  742. X    retcode = myfexecv(av[0], av);
  743. X    Myprocess->pr_WindowPtr = NULL;
  744. X    }
  745. Xif (retcode < 0) {
  746. X    char *copy;
  747. X    if ((path = FindIt(av[0],".sh",buf)) == NULL) {
  748. X        fprintf(stderr,"Command Not Found %s\n",av[0]);
  749. X        return -1;
  750. X        }
  751. X    av[1] = buf;               /* particular to do_source() */
  752. X    copy = malloc(strlen(str)+3);
  753. X    sprintf(copy,"x %s",str);
  754. X    retcode = do_source(copy);
  755. X    free(copy);
  756. X    }
  757. Xreturn retcode;
  758. X}
  759. X
  760. Xchar *dofind(cmd, ext, buf)
  761. Xchar *cmd, *ext, *buf;
  762. X{
  763. Xchar *ptr, *s;
  764. X
  765. Xsprintf(buf,"%s%s",cmd,ext);
  766. Xif (exists(buf)) return buf;
  767. Xif (BaseName(buf)==buf) {
  768. X    s = get_var(LEVEL_SET, v_path);
  769. X    while (*s) {
  770. X        for (ptr=buf; *s && *s!=','; ) *ptr++ = *s++;
  771. X        sprintf(ptr, "%s%s", cmd, ext);
  772. X        if (exists(buf)) return buf;
  773. X        if (*s) s++;
  774. X        }
  775. X    }
  776. Xreturn NULL;
  777. X}
  778. X
  779. Xchar *FindIt(cmd,ext,buf)
  780. Xchar *cmd, *ext, *buf;
  781. X{
  782. Xchar *response;
  783. X
  784. XMyprocess->pr_WindowPtr = (APTR)(-1);
  785. Xresponse=dofind(cmd,ext,buf);
  786. XMyprocess->pr_WindowPtr = NULL;
  787. Xreturn response;
  788. X}
  789. X
  790. Xmyfexecv(cmd, argv)
  791. Xchar *cmd, **argv;
  792. X{
  793. Xlong ret_val;
  794. Xstruct FileHandle *fhp;
  795. XAPTR sav_ret;
  796. Xregister char **ap, *cp, *arg;
  797. Xlong len, seg, sav, stksiz;
  798. Xchar buf[40];
  799. Xunion {
  800. X    long *lp;
  801. X    long ll;
  802. X    } l, stk;
  803. Xlong oldcin, oldcout;
  804. Xlong doexec();
  805. Xextern long _savsp;
  806. X
  807. Xif (seg = LoadPrg(cmd)) goto found;
  808. Xl.lp = (long *) Mycli->cli_CommandDir;
  809. Xwhile (l.ll) {
  810. X    l.ll <<= 2;
  811. X    sav = CurrentDir(l.lp[1]);
  812. X    seg = LoadPrg(cmd);
  813. X    CurrentDir(sav);
  814. X    if (seg) goto found;
  815. X    l.ll = *l.lp;
  816. X    }
  817. Xsprintf(buf, "c:%s", cmd);
  818. Xif (seg = LoadPrg(buf)) goto found;
  819. Xreturn -1;
  820. X
  821. Xfound:
  822. X
  823. Xstksiz = 4 * Mycli->cli_DefaultStack;
  824. Xif ((stk.lp = AllocMem(stksiz+8, 0L)) == 0) {
  825. X    UnLoadPrg(seg);
  826. X    return -1;
  827. X    }
  828. Xfor (len=0,ap=argv+1;*ap;ap++)
  829. X    len += strlen(*ap) + 1;
  830. Xif (len==0) len++;
  831. Xif ((cp = arg = AllocMem(len, 0L)) == 0) {
  832. X    UnLoadPrg(seg);
  833. X    FreeMem(stk.lp, stksiz+8);
  834. X    return -1;
  835. X    }
  836. X*stk.lp = stksiz + 8;
  837. Xstk.ll += stksiz;
  838. Xstk.lp[0] = stksiz;
  839. Xstk.lp[1] = ((long *)_savsp)[2];
  840. Xsav_ret = Myprocess->pr_ReturnAddr;
  841. XMyprocess->pr_ReturnAddr = (APTR) stk.lp;
  842. X
  843. Xsav = Mycli->cli_Module;
  844. XMycli->cli_Module = seg;
  845. X
  846. Xfor (ap=argv+1;*ap;ap++) {
  847. X    strcpy(cp, *ap);
  848. X    if (ap[1]) strcat(cp, " ");
  849. X    cp += strlen(cp);
  850. X    }
  851. Xif (len==1) arg[1]='\0';
  852. Xarg[len-1] = '\n';
  853. X
  854. Xcp = (char *)((long)Mycli->cli_CommandName << 2);
  855. Xmovmem(cp, buf, 40);
  856. Xstrcpy(cp+1, cmd);
  857. Xcp[0] = strlen(cmd);
  858. X
  859. Xfhp = (struct FileHandle *) (Myprocess->pr_CIS << 2);
  860. Xstrncpy(fhp->fh_Buf<<2, arg, (int)(len < 200?len:199));
  861. Xfhp->fh_Pos = 0;
  862. Xfhp->fh_End = len < 200?len:199;
  863. Xoldcin  = Myprocess->pr_CIS;
  864. Xoldcout = Myprocess->pr_COS;
  865. X
  866. Xret_val = doexec(len, stksiz, stksiz+8, len, arg, (seg+1)<<2, stk.ll);
  867. X
  868. XMyprocess->pr_CIS = oldcin;
  869. XMyprocess->pr_COS = oldcout;
  870. Xfhp->fh_Pos = fhp->fh_End;
  871. XUnLoadPrg(Mycli->cli_Module);
  872. XMyprocess->pr_ReturnAddr = sav_ret;
  873. XMycli->cli_Module = sav;
  874. XFreeMem(arg, len);
  875. Xmovmem(buf, cp, 40);
  876. Xreturn ret_val;
  877. X}
  878. X
  879. Xstatic long doexec()
  880. X{
  881. X#asm
  882. X    movem.l    d3-d7/a2-a5,-(sp)        ;save registers
  883. X    lea        savsp(pc),a0
  884. X    move.l    sp,(a0)                    ;save our sp
  885. X    movem.l    8(a5),d0/d2/d3/d4/a0/a4/a7    ;load params
  886. X    move.l    4(sp),a3                ;get old sp from CLI
  887. X    movem.l    4(a3),a1/a2/a5/a6        ;get BCPL environment
  888. X    move.l    d0,12(a1)                ;set length
  889. X    move.l    a0,d1                    ;copy to dreg
  890. X    lsr.l    #2,d1                    ;convert to BPTR
  891. X    move.l    d1,8(a1)                ;set ptr
  892. X    move.l    a0,d1                    ;copy to d1 as well
  893. X    jsr        (a4)                    ;call new program
  894. X    movem.l    (sp)+,d2/d3                ;get stk siz and old sp
  895. X    move.l    sp,a1                    ;save current sp
  896. X    move.l    savsp(pc),sp            ;get back our sp
  897. X    movem.l    (sp)+,d3-d7/a2-a5        ;get back registers
  898. X    move.l    d0,-(sp)                ;save return code
  899. X    sub.l    d2,a1                    ;back up a bit
  900. X    sub.l    #8,a1                    ;back up over header
  901. X    move.l    (a1),d0                    ;get size to free
  902. X    move.l    4,a6                    ;get ExecBase
  903. X    jsr        -210(a6)                ;free the memory
  904. X    move.l    (sp)+,d0                ;get the return code
  905. X#endasm
  906. X}
  907. X
  908. X#asm
  909. Xsavsp:
  910. X    dc.l    0
  911. X#endasm
  912. SHAR_EOF
  913. echo "extracting set.c"
  914. sed 's/^X//' << \SHAR_EOF > set.c
  915. X
  916. X/*
  917. X * SET.C
  918. X *
  919. X * (c)1986 Matthew Dillon     9 October 1986
  920. X *
  921. X * Version 2.07M by Steve Drew 10-Sep-87
  922. X *
  923. X * Version 3.03A by Carlo Borreo & Cesare Dieni 12-May-89
  924. X *
  925. X */
  926. X
  927. Xextern char *v_titlebar, *v_verbose, *v_hist, *v_debug, *v_prompt;
  928. Xextern struct Window *w;
  929. X
  930. X#define MAXLEVELS (3 + MAXSRC)
  931. X
  932. Xstruct MASTER {
  933. X    struct MASTER *next;
  934. X    struct MASTER *last;
  935. X    char *name;
  936. X    char *text;
  937. X};
  938. X
  939. Xstatic struct MASTER *Mbase[MAXLEVELS];
  940. X
  941. Xchar *set_var(level, name, str)
  942. Xregister char *name, *str;
  943. X{
  944. X   register struct MASTER *base = Mbase[level];
  945. X   register struct MASTER *last;
  946. X   register int len;
  947. X
  948. X   for (len = 0; isalphanum(name[len]); ++len);
  949. X   while (base != NULL) {
  950. X      if (strlen(base->name) == len && strncmp (name, base->name, len) == 0) {
  951. X         Free (base->text);
  952. X         goto gotit;
  953. X      }
  954. X      last = base;
  955. X      base = base->next;
  956. X   }
  957. X   if (base == Mbase[level]) {
  958. X      base = Mbase[level] = (struct MASTER *)malloc (sizeof(struct MASTER));
  959. X      base->last = NULL;
  960. X   } else {
  961. X      base = (struct MASTER *)malloc (sizeof(struct MASTER));
  962. X      base->last = last;
  963. X      last->next = base;
  964. X   }
  965. X   base->name = malloc (len + 1);
  966. X   bmov (name, base->name, len);
  967. X   base->name[len] = 0;
  968. X   base->next = NULL;
  969. Xgotit:
  970. X   base->text = malloc (strlen(str) + 1);
  971. X   strcpy (base->text, str);
  972. X   if (*name=='_') sys_vars();
  973. X   return (base->text);
  974. X}
  975. X
  976. Xchar *get_var (level, name)
  977. Xregister char *name;
  978. X{
  979. X   register struct MASTER *base = Mbase[level];
  980. X   register unsigned char *scr;
  981. X   register int len;
  982. X
  983. X   for (scr = (unsigned char *)name; *scr && *scr != 0x80 && *scr != ' ' && *scr != ';' && *scr != '|'; ++scr);
  984. X   len = scr - name;
  985. X
  986. X   while (base != NULL) {
  987. X      if (strlen(base->name) == len && strncmp (name, base->name, len) == 0)
  988. X         return (base->text);
  989. X      base = base->next;
  990. X   }
  991. X   return (NULL);
  992. X}
  993. X
  994. Xunset_level(level)
  995. X{
  996. X   register struct MASTER *base = Mbase[level];
  997. X
  998. X   while (base) {
  999. X      Free (base->name);
  1000. X      Free (base->text);
  1001. X      Free (base);
  1002. X      base = base->next;
  1003. X   }
  1004. X   Mbase[level] = NULL;
  1005. X}
  1006. X
  1007. Xunset_var(level, name)
  1008. Xchar *name;
  1009. X{
  1010. X   register struct MASTER *base = Mbase[level];
  1011. X   register struct MASTER *last = NULL;
  1012. X   register int len;
  1013. X
  1014. X   for (len = 0; isalphanum(name[len]); ++len);
  1015. X   while (base) {
  1016. X      if (strlen(base->name) == len && strncmp (name, base->name, len) == 0) {
  1017. X         if (base != Mbase[level])
  1018. X            last->next = base->next;
  1019. X         else
  1020. X            Mbase[level] = base->next;
  1021. X         if (base->next != NULL)
  1022. X            base->next->last = last;
  1023. X         if (base == Mbase[level])
  1024. X            Mbase[level] = base->next;
  1025. X         Free (base->name);
  1026. X         Free (base->text);
  1027. X         Free (base);
  1028. X         return (1);
  1029. X      }
  1030. X      last = base;
  1031. X      base = base->next;
  1032. X   }
  1033. X   return (-1);
  1034. X}
  1035. X
  1036. Xdo_unset_var(str, level)
  1037. Xchar *str;
  1038. X{
  1039. Xregister unsigned int i;
  1040. X
  1041. Xfor (i = 1; i < ac; ++i) unset_var (level, av[i]);
  1042. Xsys_vars();
  1043. Xreturn 0;
  1044. X}
  1045. X
  1046. Xdo_set_var(command, level)
  1047. Xchar *command;
  1048. X{
  1049. Xregister struct MASTER *base = Mbase[level];
  1050. Xregister char *str;
  1051. X
  1052. Xswitch (ac) {
  1053. Xcase 1:
  1054. X    while (base && !dobreak()) {
  1055. X        printf ("\2330m%-10s %s\n", base->name, base->text);
  1056. X        base = base->next;
  1057. X        }
  1058. X    break;
  1059. Xcase 2:
  1060. X    if (str=get_var(level,av[1])) printf ("%-10s %s\n", av[1], str);
  1061. X    break;
  1062. Xdefault:
  1063. X    set_var (level, av[1], next_word (next_word (command)));
  1064. X    if (*av[1]=='_') sys_vars();
  1065. X    break;
  1066. X    }
  1067. Xreturn 0;
  1068. X}
  1069. X
  1070. Xextern char trueprompt[100];
  1071. X
  1072. Xsys_vars()
  1073. X{
  1074. Xregister char *str, *t;
  1075. X
  1076. Xif (strcmp(w->Title, str=get_var(LEVEL_SET, v_titlebar)))
  1077. X    SetWindowTitles(w, str, -1L);
  1078. XS_histlen=(str = get_var(LEVEL_SET, v_hist)) ? atoi(str) : 0;
  1079. Xdebug  =(get_var(LEVEL_SET, v_debug)  !=NULL);
  1080. XVerbose=(get_var(LEVEL_SET, v_verbose)!=NULL);
  1081. Xif (S_histlen < 2) S_histlen=2;
  1082. X
  1083. Xif ( (str=get_var(LEVEL_SET,v_prompt)) ==NULL) str="$ ";
  1084. Xt=trueprompt;
  1085. Xwhile (*str)
  1086. X    if (*str=='%' && Toupper(str[1])=='P') {
  1087. X        str+=2;
  1088. X        strcpy(t,get_var(LEVEL_SET,"_cwd"));
  1089. X        t+=strlen(t);
  1090. X        }
  1091. X    else *t++=*str++;
  1092. Xstrcpy(t,"\2330m");
  1093. X}
  1094. SHAR_EOF
  1095. echo "extracting shell.h"
  1096. sed 's/^X//' << \SHAR_EOF > shell.h
  1097. X
  1098. X/*
  1099. X * SHELL.H
  1100. X *
  1101. X * (c)1986 Matthew Dillon     9 October 1986
  1102. X *
  1103. X *
  1104. X * SHELL include file.. contains shell parameters and extern's
  1105. X *
  1106. X * Version 2.07M by Steve Drew 10-Sep-87
  1107. X *
  1108. X * Version 3.02A by Carlo Borreo & Cesare Dieni 20-Dec-88
  1109. X *
  1110. X */
  1111. X
  1112. X#define RAW_CONSOLE 1   /* Set to 0 to compile out Cmd Line Editing */
  1113. X
  1114. X#include <stdio.h>
  1115. X#include <exec/exec.h>
  1116. X#include <time.h>
  1117. X#include <libraries/dos.h>
  1118. X#include <libraries/dosextens.h>
  1119. X#include <intuition/intuition.h>
  1120. X#include <intuition/intuitionbase.h>
  1121. X#include "shellfunctions.h"
  1122. X#include <fcntl.h>
  1123. X#include <libraries/arpbase.h>
  1124. X#include <arpfunctions.h>
  1125. X
  1126. Xtypedef struct FileInfoBlock FIB;
  1127. X
  1128. X#define bmov movmem
  1129. X
  1130. X#define MAXAV        256        /* Max. # arguments        */
  1131. X#define MAXSRC        5        /* Max. # of source file levels */
  1132. X#define MAXIF        10        /* Max. # of if levels        */
  1133. X#define MAXALIAS    20        /* Max. # of alias levels    */
  1134. X#define MAXMYFILES    9        /* Max. # of internal files    */
  1135. X
  1136. X#define LEVEL_SET    0        /* which variable list to use   */
  1137. X#define LEVEL_ALIAS    1
  1138. X#define LEVEL_LABEL    2
  1139. X
  1140. X    /* EXECOM.C defines */
  1141. X
  1142. X#define FL_DOLLAR    0x01  /* One of the following */
  1143. X#define FL_BANG        0x02
  1144. X#define FL_PERCENT    0x04
  1145. X#define FL_QUOTE    0x08
  1146. X#define FL_IDOLLAR    0x10  /* Any or all of the following may be set */
  1147. X#define FL_EOC        0x20
  1148. X#define FL_EOL        0x40
  1149. X#define FL_OVERIDE    0x80
  1150. X#define FL_WILD        0x100
  1151. X#define FL_MASK        (FL_DOLLAR|FL_BANG|FL_PERCENT|FL_QUOTE)
  1152. X
  1153. X#ifndef NULL
  1154. X#define NULL 0L
  1155. X#endif
  1156. X
  1157. X#define CHECKBREAK() dobreak()
  1158. X
  1159. X#ifndef AZTEC_C
  1160. Xstruct _dev {
  1161. X    long  fd;
  1162. X    short mode;
  1163. X    };
  1164. X#endif
  1165. X
  1166. Xstruct HIST {
  1167. X    struct HIST *next, *prev;    /* doubly linked list */
  1168. X    char *line;            /* line in history    */
  1169. X};
  1170. X
  1171. Xstruct PERROR {
  1172. X    int errnum;            /* Format of global error lookup */
  1173. X    char *errstr;
  1174. X};
  1175. X
  1176. Xstruct DPTR {                /* Format of directory fetch pointer */
  1177. X    BPTR lock;            /* lock on directory   */
  1178. X    FIB *fib;            /* mod'd fib for entry */
  1179. X    };
  1180. X
  1181. Xextern struct HIST *H_head, *H_tail;
  1182. Xextern struct PERROR Perror[];
  1183. Xextern struct DPTR *dopen();
  1184. Xextern char *set_var(), *get_var(), *next_word();
  1185. Xextern char *get_history(), *compile_av(), *get_pwd();
  1186. Xextern char *malloc(), *strcpy(), *strcat(), *index();
  1187. Xextern char **expand();
  1188. Xextern char *av[];
  1189. Xextern char *Current;
  1190. Xextern int  H_len, H_tail_base, H_stack;
  1191. Xextern int  E_stack;
  1192. Xextern int  Src_stack, If_stack, forward_goto;
  1193. Xextern int  ac;
  1194. Xextern int  debug, Rval, Verbose, disable, Quit;
  1195. Xextern int  Lastresult;
  1196. Xextern int  Exec_abortline;
  1197. Xextern int   S_histlen;
  1198. Xextern unsigned int options;
  1199. Xextern long  Cin, Cout, Cout_append;
  1200. Xextern char *Cin_name, *Cout_name;
  1201. Xextern char  Cin_type,  Cout_type;  /* these variables are in transition */
  1202. Xextern char *Pipe1, *Pipe2;
  1203. X
  1204. Xextern long Errno;
  1205. Xextern long Src_base[MAXSRC];
  1206. Xextern long Src_pos[MAXSRC];
  1207. Xextern char If_base[MAXIF];
  1208. Xextern struct Process *Myprocess;
  1209. Xextern struct CommandLineInterface *Mycli;
  1210. X
  1211. Xextern long atol(), Atol(), myatol();
  1212. SHAR_EOF
  1213. echo "extracting shellfunctions.h"
  1214. sed 's/^X//' << \SHAR_EOF > shellfunctions.h
  1215. Xtypedef    long    cList;
  1216. Xextern int Enable_Abort;
  1217. X
  1218. Xlong                    AbleICR();
  1219. Xlong                    AbortIO();
  1220. Xlong                    ActivateGadget();
  1221. Xvoid                    ActivateWindow();
  1222. Xvoid                    AddAnimOb();
  1223. Xvoid                    AddBob();
  1224. Xvoid                    AddConfigDev();
  1225. Xvoid                    AddDevice();
  1226. Xlong                    AddDosNode();
  1227. Xvoid                    AddFont();
  1228. Xvoid                    AddFreeList();
  1229. Xshort                    AddGadget();
  1230. Xunsigned short                AddGList();
  1231. Xvoid                    AddHead();
  1232. Xstruct Interrupt *            AddICRVector();
  1233. Xvoid                    AddIntServer();
  1234. Xvoid                    AddLibrary();
  1235. Xlong                    AddMemList();
  1236. Xvoid                    AddPort();
  1237. Xvoid                    AddResource();
  1238. Xvoid                    AddSemaphore();
  1239. Xvoid                    AddTail();
  1240. Xvoid                    AddTask();
  1241. Xvoid                    AddTime();
  1242. Xvoid                    AddVSprite();
  1243. Xlong                    Alert();
  1244. Xvoid *                    AllocAbs();
  1245. Xlong                    AllocBoardMem();
  1246. XcList                    AllocCList();
  1247. Xstruct ConfigDev *            AllocConfigDev();
  1248. Xstruct MemList *            AllocEntry();
  1249. Xunsigned long                AllocExpansionMem();
  1250. Xvoid *                    AllocMem();
  1251. Xlong                    AllocPotBits();
  1252. Xvoid *                    AllocRaster();
  1253. Xchar *                    AllocRemember();
  1254. Xlong                    AllocSignal();
  1255. Xlong                    AllocTrap();
  1256. Xstruct WBObject *            AllocWBObject();
  1257. Xvoid *                    Allocate();
  1258. Xvoid                    AlohaWorkbench();
  1259. Xvoid                    AndRectRegion();
  1260. Xlong                    AndRegionRegion();
  1261. Xvoid                    Animate();
  1262. Xshort                    AreaDraw();
  1263. Xlong                    AreaEllipse();
  1264. Xvoid                    AreaEnd();
  1265. Xshort                    AreaMove();
  1266. Xvoid                    AskFont();
  1267. Xlong                    AskSoftStyle();
  1268. Xlong                    AttemptLockLayerRom();
  1269. Xlong                    AttemptSemaphore();
  1270. Xshort                    AutoRequest();
  1271. Xlong                    AvailFonts();
  1272. Xlong                    AvailMem();
  1273. Xvoid                    BeginIO();
  1274. Xvoid                    BeginRefresh();
  1275. Xvoid                    BeginUpdate();
  1276. Xvoid                    BeginLayer();
  1277. Xlong                    BltBitMap();
  1278. Xlong                    BltBitMapRastPort();
  1279. Xvoid                    BltClear();
  1280. Xvoid                    BltMaskBitMapRastPort();
  1281. Xvoid                    BltPattern();
  1282. Xvoid                    BltTemplate();
  1283. Xstruct Window *                BuildSysRequest();
  1284. Xchar *                    BumpRevision();
  1285. Xvoid                    Cause();
  1286. Xvoid                    CBump();
  1287. Xstruct Events *                CDInputHandler();
  1288. Xvoid                    ChangeSprite();
  1289. Xstruct IORequest *            CheckIO();
  1290. Xshort                    ClearDMRequest();
  1291. Xvoid                    ClearEOL();
  1292. Xvoid                    ClearMenuStrip();
  1293. Xvoid                    ClearPointer();
  1294. Xvoid                    ClearRegion();
  1295. Xlong                    ClearRectRegion();
  1296. Xvoid                    ClearScreen();
  1297. Xvoid                    ClipBit();
  1298. Xvoid                    Close();
  1299. Xvoid                    CloseDevice();
  1300. Xvoid                    CloseFont();
  1301. Xvoid                    CloseLibrary();
  1302. Xvoid                    CloseScreen();
  1303. Xvoid                    CloseWindow();
  1304. Xshort                    CloseWorkBench();
  1305. Xvoid                    CMove();
  1306. Xshort                    CmpTime();
  1307. Xlong                    ConcatCList();
  1308. Xlong                    ConfigBoard();
  1309. Xlong                    ConfigChain();
  1310. Xlong                    ConsoleDevice();
  1311. Xlong                    CopperListInit();
  1312. XcList                    CopyCList();
  1313. Xvoid                    CopyMem();
  1314. Xvoid                    CopyMemQuick();
  1315. Xvoid                    CopySBitMap();
  1316. Xstruct Layer *                CreateBehindLayer();
  1317. XBPTR        CreateDir();
  1318. Xstruct MsgPort *            CreatePort();
  1319. Xstruct Process *            CreateProc();
  1320. Xstruct IOStdReq *            CreateStdIO();
  1321. Xstruct Task *                CreateTask();
  1322. Xstruct Layer *                CreateUpfrontLayer();
  1323. XBPTR                    CurrentDir();
  1324. Xvoid                    CurrentTime();
  1325. Xvoid                    CWait();
  1326. Xlong *                    DateStamp();
  1327. Xvoid                    Deallocate();
  1328. Xvoid                    Debug();
  1329. Xvoid                    Delay();
  1330. Xshort                    DeleteFile();
  1331. Xvoid                    DeleteLayer();
  1332. Xvoid                    DeletePort();
  1333. Xvoid                    DeleteStdIO();
  1334. Xvoid                    DeleteTask();
  1335. Xstruct Process *            DeviceProc();
  1336. Xvoid                    Disable();
  1337. Xvoid                    DisownBlitter();
  1338. Xshort                    DisplayAlert();
  1339. Xvoid                    DisplayBeep();
  1340. Xvoid                    DisposeRegion();
  1341. Xvoid                    DoCollision();
  1342. Xlong                    DoIO();
  1343. Xshort                    DoubleClick();
  1344. Xvoid                    Draw();
  1345. Xvoid                    DrawBorder();
  1346. Xvoid                    DrawEllipse();
  1347. Xvoid                    DrawGList();
  1348. Xvoid                    DrawImage();
  1349. XBPTR                    DupLock();
  1350. Xvoid                    Enable();
  1351. Xvoid                    EndRefresh();
  1352. Xvoid                    EndRequest();
  1353. Xvoid                    EndUpdate();
  1354. Xvoid                    Enqueue();
  1355. Xshort                    ExNext();
  1356. Xshort                    Examine();
  1357. Xshort                    Execute();
  1358. Xvoid                    Exit();
  1359. Xstruct ConfigDev *            FindConfigDev();
  1360. Xstruct Node *                FindName();
  1361. Xstruct MsgPort *            FindPort();
  1362. Xstruct Resident *            FindResident();
  1363. Xstruct SignalSemaphore *        FindSemaphore();
  1364. Xstruct Task *                FindTask();
  1365. Xchar *                    FindToolType();
  1366. Xshort                    Flood();
  1367. Xvoid                    FlushCList();
  1368. Xvoid                    Forbid();
  1369. Xvoid                    FreeBoardMem();
  1370. Xvoid                    FreeCList();
  1371. Xvoid                    FreeColorMap();
  1372. Xvoid                    FreeConfigDev();
  1373. Xvoid                    FreeCopList();
  1374. Xvoid                    FreeCprList();
  1375. Xvoid                    FreeDiskObject();
  1376. Xvoid                    FreeEntry();
  1377. Xvoid                    FreeExpansionMem();
  1378. Xvoid                    FreeFreeList();
  1379. Xvoid                    FreeGBuffers();
  1380. Xvoid                    FreeMem();
  1381. Xvoid                    FreePotBits();
  1382. Xvoid                    FreeRaster();
  1383. Xvoid                    FreeRemember();
  1384. Xvoid                    FreeSignal();
  1385. Xvoid                    FreeSprite();
  1386. Xvoid                    FreeSysRequest();
  1387. Xvoid                    FreeTrap();
  1388. Xvoid                    FreeVPortCopLists();
  1389. Xvoid                    FreeWBObject();
  1390. Xlong                    GetCC();
  1391. Xlong                    GetCLBuf();
  1392. Xshort                    GetCLChar();
  1393. Xshort                    GetCLWord();
  1394. Xstruct ColorMap *            GetColorMap();
  1395. Xlong                    GetCurrentBinding();
  1396. Xstruct Preferences *            GetDefPrefs();
  1397. Xstruct DiskObject *            GetDiskObject();
  1398. Xshort                    GetGBuffers();
  1399. Xlong                    GetIcon();
  1400. Xstruct Message *            GetMsg();
  1401. Xstruct Preferences *            GetPrefs();
  1402. Xshort                    GetRGB4();
  1403. Xlong                    GetScreenData();
  1404. Xshort                    GetSprite();
  1405. Xstruct WBObject *            GetWBObject();
  1406. Xlong                    IncrCLMark();
  1407. Xshort                    Info();
  1408. Xvoid                    InitArea();
  1409. Xvoid                    InitBitMap();
  1410. Xlong                    InitCLPool();
  1411. Xvoid                    InitCode();
  1412. Xvoid                    InitGMasks();
  1413. Xvoid                    InitGels();
  1414. Xvoid                    InitMasks();
  1415. Xvoid                    InitRastPort();
  1416. Xvoid                    InitRequester();
  1417. Xvoid                    InitResident();
  1418. Xvoid                    InitSemaphore();
  1419. Xvoid                    InitStruct();
  1420. Xvoid                    InitTmpRas();
  1421. Xvoid                    InitVPort();
  1422. Xvoid                    InitView();
  1423. XBPTR                    Input();
  1424. Xvoid                    Insert();
  1425. Xstruct Region *                InstallClipRegion();
  1426. Xlong                    IntuiTextLength();
  1427. Xstruct InputEvent *            Intuition();
  1428. Xlong                    IoErr();
  1429. Xshort                    IsInteractive();
  1430. Xstruct MenuItem *            ItemAddress();
  1431. Xvoid                    LoadRGB4();
  1432. Xstruct Segment *            LoadSeg();
  1433. Xvoid                    LoadView();
  1434. XBPTR                    Lock();
  1435. Xvoid                    LockLayer();
  1436. Xvoid                    LockLayerInfo();
  1437. Xvoid                    LockLayerRom();
  1438. Xvoid                    LockLayers();
  1439. Xstruct DeviceNode *            MakeDosNode();
  1440. Xlong                    MakeFunctions();
  1441. Xstruct Library *            MakeLibrary();
  1442. Xvoid                    MakeScreen();
  1443. Xvoid                    MakeVPort();
  1444. Xlong                    MarkCList();
  1445. Xlong                    MatchToolValue();
  1446. Xvoid                    ModifyIDCMP();
  1447. Xvoid                    ModifyProp();
  1448. Xvoid                    Move();
  1449. Xlong                    MoveLayer();
  1450. Xvoid                    MoveScreen();
  1451. Xvoid                    MoveSprite();
  1452. Xvoid                    MoveWindow();
  1453. Xvoid                    MrgCop();
  1454. Xvoid                    NewList();
  1455. Xvoid                    NewModifyProp();
  1456. Xstruct Region *                NewRegion();
  1457. Xvoid                    ObtainConfigBinding();
  1458. Xvoid                    ObtainSemaphore();
  1459. Xvoid                    ObtainSemaphoreList();
  1460. Xvoid                    OffGadget();
  1461. Xvoid                    OffMenu();
  1462. Xvoid                    OnGadget();
  1463. Xvoid                    OnMenu();
  1464. XBPTR                    Open();
  1465. Xlong                    OpenDevice();
  1466. Xstruct Font *                OpenDiskFont();
  1467. Xstruct Font *                OpenFont();
  1468. Xvoid                    OpenIntuition();
  1469. Xstruct Library *            OpenLibrary();
  1470. Xstruct MiscResource *            OpenResource();
  1471. Xstruct Screen *                OpenScreen();
  1472. Xstruct Window *                OpenWindow();
  1473. Xshort                    OpenWorkBench();
  1474. Xvoid                    OrRectRegion();
  1475. Xlong                    OrRegionRegion();
  1476. XBPTR                    Output();
  1477. Xvoid                    OwnBlitter();
  1478. XBPTR                    ParentDir();
  1479. Xshort                    PeekCLMark();
  1480. Xvoid                    Permit();
  1481. Xvoid                    PolyDraw();
  1482. Xvoid                    PrintIText();
  1483. Xlong                    PutCLBuf();
  1484. Xlong                    PutCLChar();
  1485. Xlong                    PutCLWord();
  1486. Xshort                    PutDiskObject();
  1487. Xlong                    PutIcon();
  1488. Xvoid                    PutMsg();
  1489. Xlong                    PutWBObject();
  1490. Xvoid                    QBSBlit();
  1491. Xvoid                    QBlit();
  1492. Xshort                    RawKeyConvert();
  1493. Xlong                    Read();
  1494. Xchar                    ReadExpansionByte();
  1495. Xlong                    ReadExpansionRom();
  1496. Xshort                    ReadPixel();
  1497. Xvoid                    RectFill();
  1498. Xvoid                    RefreshGadgets();
  1499. Xvoid                    RefreshGList();
  1500. Xvoid                    RefreshWindowFrame();
  1501. Xvoid                    ReleaseConfigBinding();
  1502. Xvoid                    ReleaseSemaphore();
  1503. Xvoid                    ReleaseSemaphoreList();
  1504. Xvoid                    RemConfigDev();
  1505. Xlong                    RemDevice();
  1506. Xvoid                    RemFont();
  1507. Xstruct Node *                RemHead();
  1508. Xvoid                    RemIBob();
  1509. Xvoid                    RemICRVector();
  1510. Xvoid                    RemIntServer();
  1511. Xlong                    RemLibrary();
  1512. Xunsigned short                RemoveGList();
  1513. Xvoid                    RemPort();
  1514. Xvoid                    RemResource();
  1515. Xvoid                    RemSemaphore();
  1516. Xstruct Node *                RemTail();
  1517. Xvoid                    RemTask();
  1518. Xvoid                    RemVSprite();
  1519. Xvoid                    RemakeDisplay();
  1520. Xvoid                    Remove();
  1521. Xunsigned short                RemoveGadget();
  1522. Xshort                    Rename();
  1523. Xvoid                    ReplyMsg();
  1524. Xvoid                    ReportMouse();
  1525. Xshort                    Request();
  1526. Xvoid                    RethinkDisplay();
  1527. Xvoid                    ScreenToBack();
  1528. Xvoid                    ScreenToFront();
  1529. Xvoid                    ScrollLayer();
  1530. Xvoid                    ScrollRaster();
  1531. Xvoid                    ScrollVPort();
  1532. Xlong                    Seek();
  1533. Xvoid                    SendIO();
  1534. Xvoid                    SetAPen();
  1535. Xvoid                    SetBPen();
  1536. Xvoid                    SetCollision();
  1537. Xshort                    SetComment();
  1538. Xvoid                    SetCurrentBinding();
  1539. Xshort                    SetDMRequest();
  1540. Xvoid                    SetDRMd();
  1541. Xlong                    SetExcept();
  1542. Xlong                    SetFont();
  1543. Xlong                    SetFunction();
  1544. Xlong                    SetICR();
  1545. Xstruct Interrupt *            SetIntVector();
  1546. Xshort                    SetMenuStrip();
  1547. Xvoid                    SetPointer();
  1548. Xstruct Preferences *            SetPrefs();
  1549. Xshort                    SetProtection();
  1550. Xvoid                    SetRast();
  1551. Xvoid                    SetRGB4();
  1552. Xvoid                    SetRGB4CM();
  1553. Xlong                    SetSR();
  1554. Xlong                    SetSignal();
  1555. Xlong                    SetSoftStyle();
  1556. Xshort                    SetTaskPri();
  1557. Xvoid                    SetWindowTitles();
  1558. Xvoid                    ShowTitle();
  1559. Xvoid                    Signal();
  1560. Xlong                    SizeCList();
  1561. Xshort                    SizeLayer();
  1562. Xvoid                    SizeWindow();
  1563. Xvoid                    SortGList();
  1564. XcList                    SplitCList();
  1565. XcList                    SubCList();
  1566. Xvoid                    SubTime();
  1567. Xvoid                    SubLibrary();
  1568. Xvoid                    SumKickData();
  1569. Xlong                    SuperState();
  1570. Xvoid                    SwapBitsRastPortClipRect();
  1571. Xvoid                    SyncSBitMap();
  1572. Xlong                    Text();
  1573. Xlong                    TextLength();
  1574. Xlong                    Translate();
  1575. Xlong                    UnGetCLChar();
  1576. Xlong                    UnGetCLWord();
  1577. Xvoid                    UnLoadSeg();
  1578. Xvoid                    UnLock();
  1579. Xshort                    UnPutCLChar();
  1580. Xshort                    UnPutCLWord();
  1581. Xvoid                    UnlockLayer();
  1582. Xvoid                    UnlockLayerInfo();
  1583. Xvoid                    UnlockLayerRom();
  1584. Xvoid                    UnlockLayers();
  1585. Xshort                    UpfrontLayer();
  1586. Xvoid                    UserState();
  1587. Xshort                    VBeamPos();
  1588. Xstruct View *                ViewAddress();
  1589. Xstruct ViewPort *            ViewPortAddress();
  1590. Xshort                    WBenchToBack();
  1591. Xshort                    WBenchToFront();
  1592. Xlong                    Wait();
  1593. Xvoid                    WaitBOVP();
  1594. Xvoid                    WaitBlit();
  1595. Xshort                    WaitForChar();
  1596. Xlong                    WaitIO();
  1597. Xstruct Message *            WaitPort();
  1598. Xvoid                    WaitTOF();
  1599. Xstruct Layer *                WhichLayer();
  1600. Xshort                    WindowLimits();
  1601. Xvoid                    WindowToBack();
  1602. Xvoid                    WindowToFront();
  1603. Xlong                    Write();
  1604. Xlong                    WriteExpansionByte();
  1605. Xvoid                    WritePixel();
  1606. Xvoid                    WritePotgo();
  1607. Xvoid                    XorRectRegion();
  1608. Xlong                    XorRegionRegion();
  1609. SHAR_EOF
  1610. echo "extracting sub.c"
  1611. sed 's/^X//' << \SHAR_EOF > sub.c
  1612. X
  1613. X/*
  1614. X * SUB.C
  1615. X *
  1616. X * (c)1986 Matthew Dillon     9 October 1986
  1617. X *
  1618. X * Version 2.07M by Steve Drew 10-Sep-87
  1619. X *
  1620. X * Version 3.03A by Carlo Borreo & Cesare Dieni 12-May-89
  1621. X *
  1622. X */
  1623. X
  1624. Xextern char *v_lasterr, *v_stat;
  1625. X
  1626. X#define HM_STR 0              /* various HISTORY retrieval modes */
  1627. X#define HM_REL 1
  1628. X#define HM_ABS 2
  1629. X
  1630. X/* extern BPTR Clock; */
  1631. X
  1632. Xseterr()
  1633. X{
  1634. Xchar buf[32];
  1635. Xint stat;
  1636. X
  1637. Xsprintf(buf, "%d", Lastresult);
  1638. Xset_var(LEVEL_SET, v_lasterr, buf);
  1639. Xstat = atoi(get_var(LEVEL_SET, v_stat));
  1640. Xif (stat < Lastresult) stat = Lastresult;
  1641. Xsprintf(buf, "%d", stat);
  1642. Xset_var(LEVEL_SET, v_stat, buf);
  1643. X}
  1644. X
  1645. X
  1646. Xchar *
  1647. Xnext_word(str)
  1648. Xregister char *str;
  1649. X{
  1650. X   while (*str  &&  *str != ' '  &&  *str != 9 && (unsigned char)*str != 0xA0)
  1651. X      ++str;
  1652. X   while (*str  && (*str == ' ' || *str == 9 || (unsigned char)*str == 0xA0))
  1653. X      ++str;
  1654. X   return (str);
  1655. X}
  1656. X
  1657. Xchar *
  1658. Xcompile_av(av, start, end, delim)
  1659. Xchar **av;
  1660. Xunsigned char delim;
  1661. X{
  1662. Xchar *cstr;
  1663. Xint len;
  1664. Xregister unsigned int i;
  1665. X
  1666. Xlen = 0;
  1667. Xfor (i = start; i < end; ++i) len += strlen(av[i]) + 1;
  1668. Xcstr = malloc(len + 1);
  1669. X*cstr = '\0';
  1670. Xfor (i = start; i < end; ++i) {
  1671. X    if (debug) fprintf (stderr, "AV[%2d] :%s:\n", i, av[i]);
  1672. X    strcat (cstr, av[i]);
  1673. X    if (i + 1 < end) strncat(cstr, &delim, 1);
  1674. X    }
  1675. Xreturn (cstr);
  1676. X}
  1677. X
  1678. X
  1679. X/*
  1680. X * FREE(ptr)   --frees without actually freeing, so the data is still good
  1681. X *               immediately after the free.
  1682. X */
  1683. X
  1684. X
  1685. XFree(ptr)
  1686. Xchar *ptr;
  1687. X{
  1688. X   static char *old_ptr;
  1689. X
  1690. X   if (old_ptr)
  1691. X      free (old_ptr);
  1692. X   old_ptr = ptr;
  1693. X}
  1694. X
  1695. X/*
  1696. X * Add new string to history (H_head, H_tail, H_len,
  1697. X *  S_histlen
  1698. X */
  1699. X
  1700. Xadd_history(str)
  1701. Xchar *str;
  1702. X{
  1703. X   register struct HIST *hist;
  1704. X
  1705. X   if (H_head != NULL && strcmp(H_head->line, str) == 0)
  1706. X       return(0);
  1707. X   while (H_len > S_histlen)
  1708. X      del_history();
  1709. X   hist = (struct HIST *)malloc (sizeof(struct HIST));
  1710. X   if (H_head == NULL) {
  1711. X      H_head = H_tail = hist;
  1712. X      hist->next = NULL;
  1713. X   } else {
  1714. X      hist->next = H_head;
  1715. X      H_head->prev = hist;
  1716. X      H_head = hist;
  1717. X   }
  1718. X   hist->prev = NULL;
  1719. X   hist->line = malloc (strlen(str) + 1);
  1720. X   strcpy (hist->line, str);
  1721. X   ++H_len;
  1722. X}
  1723. X
  1724. Xdel_history()
  1725. X{
  1726. X   if (H_tail) {
  1727. X      --H_len;
  1728. X      ++H_tail_base;
  1729. X      free (H_tail->line);
  1730. X      if (H_tail->prev) {
  1731. X         H_tail = H_tail->prev;
  1732. X         free (H_tail->next);
  1733. X         H_tail->next = NULL;
  1734. X      } else {
  1735. X         free (H_tail);
  1736. X         H_tail = H_head = NULL;
  1737. X      }
  1738. X   }
  1739. X}
  1740. X
  1741. Xchar *
  1742. Xget_history(ptr)
  1743. Xchar *ptr;
  1744. X{
  1745. X   register struct HIST *hist;
  1746. X   register int len;
  1747. X   int mode = HM_REL;
  1748. X   int num  = 1;
  1749. X   char *str;
  1750. X   char *result = NULL;
  1751. X
  1752. X   if (ptr[1] >= '0' && ptr[1] <= '9') {
  1753. X      mode = HM_ABS;
  1754. X      num  = atoi(&ptr[1]);
  1755. X      goto skip;
  1756. X   }
  1757. X   switch (ptr[1]) {
  1758. X   case '!':
  1759. X      break;
  1760. X   case '-':
  1761. X      num += atoi(&ptr[2]);
  1762. X      break;
  1763. X   default:
  1764. X      mode = HM_STR;
  1765. X      str  = ptr + 1;
  1766. X      break;
  1767. X   }
  1768. Xskip:
  1769. X   switch (mode) {
  1770. X   case HM_STR:
  1771. X      len = strlen(str);
  1772. X      for (hist = H_head; hist; hist = hist->next) {
  1773. X         if (strncmp(hist->line, str, len) == 0 && *hist->line != '!') {
  1774. X            result = hist->line;
  1775. X            break;
  1776. X         }
  1777. X      }
  1778. X      break;
  1779. X   case HM_REL:
  1780. X      for (hist = H_head; hist && num--; hist = hist->next);
  1781. X      if (hist)
  1782. X         result = hist->line;
  1783. X      break;
  1784. X   case HM_ABS:
  1785. X      len = H_tail_base;
  1786. X      for (hist = H_tail; hist && len != num; hist = hist->prev, ++len);
  1787. X      if (hist)
  1788. X         result = hist->line;
  1789. X      break;
  1790. X   }
  1791. X   if (result) {
  1792. X      fprintf(stderr,"%s\n",result);
  1793. X      return(result);
  1794. X   }
  1795. X   printf("History failed\n");
  1796. X   return ("");
  1797. X}
  1798. X
  1799. Xreplace_head(str)
  1800. Xchar *str;
  1801. X{
  1802. X   if (str == NULL)
  1803. X      str = "";
  1804. X   if (H_head) {
  1805. X      free (H_head->line);
  1806. X      H_head->line = malloc (strlen(str)+1);
  1807. X      strcpy (H_head->line, str);
  1808. X   }
  1809. X}
  1810. X
  1811. X
  1812. XpError(str)
  1813. Xchar *str;
  1814. X{
  1815. X   int ierr = (long)IoErr();
  1816. X   ierror(str, ierr);
  1817. X}
  1818. X
  1819. Xierror(str, err)
  1820. Xregister char *str;
  1821. X{
  1822. X   register struct PERROR *per = Perror;
  1823. X
  1824. X   if (err) {
  1825. X      for (; per->errstr; ++per) {
  1826. X         if (per->errnum == err) {
  1827. X            fprintf (stderr, "%s%s%s\n",
  1828. X                  per->errstr,
  1829. X                  (str) ? ": " : "",
  1830. X                  (str) ? str : "");
  1831. X            return ((short)err);
  1832. X         }
  1833. X      }
  1834. X      fprintf (stderr, "Unknown DOS error %d %s\n", err, (str) ? str : "");
  1835. X   }
  1836. X   return ((short)err);
  1837. X}
  1838. X
  1839. X/*
  1840. X * Disk directory routines
  1841. X *
  1842. X * dptr = dopen(name, stat)
  1843. X *    struct DPTR *dptr;
  1844. X *    char *name;
  1845. X *    int *stat;
  1846. X *
  1847. X * dnext(dptr, name, stat)
  1848. X *    struct DPTR *dptr;
  1849. X *    char **name;
  1850. X *    int  *stat;
  1851. X *
  1852. X * dclose(dptr)                  -may be called with NULL without harm
  1853. X *
  1854. X * dopen() returns a struct DPTR, or NULL if the given file does not
  1855. X * exist.  stat will be set to 1 if the file is a directory.  If the
  1856. X * name is "", then the current directory is openned.
  1857. X *
  1858. X * dnext() returns 1 until there are no more entries.  The **name and
  1859. X * *stat are set.  *stat = 1 if the file is a directory.
  1860. X *
  1861. X * dclose() closes a directory channel.
  1862. X *
  1863. X */
  1864. X
  1865. Xstruct DPTR *
  1866. Xdopen(name, stat)
  1867. Xchar *name;
  1868. Xint *stat;
  1869. X{
  1870. X   struct DPTR *dp;
  1871. X
  1872. X   *stat = 0;
  1873. X   dp = (struct DPTR *)malloc(sizeof(struct DPTR));
  1874. X   if (*name == '\0')
  1875. X      dp->lock = DupLock(Myprocess->pr_CurrentDir);
  1876. X   else
  1877. X      dp->lock = Lock (name,ACCESS_READ);
  1878. X   if (dp->lock == NULL) {
  1879. X      free (dp);
  1880. X      return (NULL);
  1881. X   }
  1882. X   dp->fib = (FIB *)AllocMem((long)sizeof(FIB), MEMF_PUBLIC);
  1883. X   if (!Examine (dp->lock, dp->fib)) {
  1884. X      pError (name);
  1885. X      dclose (dp);
  1886. X      return (NULL);
  1887. X   }
  1888. X   if (dp->fib->fib_DirEntryType >= 0)
  1889. X      *stat = 1;
  1890. X   return (dp);
  1891. X}
  1892. X
  1893. Xdnext(dp, pname, stat)
  1894. Xstruct DPTR *dp;
  1895. Xchar **pname;
  1896. Xint *stat;
  1897. X{
  1898. X   if (dp == NULL)
  1899. X      return (0);
  1900. X   if (ExNext (dp->lock, dp->fib)) {
  1901. X      *stat = (dp->fib->fib_DirEntryType < 0) ? 0 : 1;
  1902. X      *pname = dp->fib->fib_FileName;
  1903. X      return (1);
  1904. X   }
  1905. X   return (0);
  1906. X}
  1907. X
  1908. X
  1909. Xdclose(dp)
  1910. Xstruct DPTR *dp;
  1911. X{
  1912. X   if (dp == NULL)
  1913. X      return (1);
  1914. X   if (dp->fib)
  1915. X      FreeMem (dp->fib,(long)sizeof(*dp->fib));
  1916. X   if (dp->lock)
  1917. X      UnLock (dp->lock);
  1918. X   free (dp);
  1919. X   return (1);
  1920. X}
  1921. X
  1922. X
  1923. Xisdir(file)
  1924. Xchar *file;
  1925. X{
  1926. X   register struct DPTR *dp;
  1927. X   int stat;
  1928. X
  1929. X   stat = 0;
  1930. X   if (dp = dopen (file, &stat))
  1931. X      dclose(dp);
  1932. X   return (stat == 1);
  1933. X}
  1934. X
  1935. X
  1936. Xfree_expand(av)
  1937. Xregister char **av;
  1938. X{
  1939. X   char **base = av;
  1940. X
  1941. X   if (av) {
  1942. X      while (*av) {
  1943. X         free (*av);
  1944. X         ++av;
  1945. X      }
  1946. X      free (base);
  1947. X   }
  1948. X}
  1949. X
  1950. X/*
  1951. X * EXPAND(base,pac)
  1952. X *    base           - char * (example: "df0:*.c")
  1953. X *    pac            - int  *  will be set to # of arguments.
  1954. X *
  1955. X * 22-May-87 SJD.  Heavily modified to allow recursive wild carding and
  1956. X *                 simple directory/file lookups. Returns a pointer to
  1957. X *                 an array of pointers that contains the full file spec
  1958. X *                 eg. 'df0:c/sear*' would result in : 'df0:C/Search'
  1959. X *
  1960. X *                 Now no longer necessary to Examine the files a second time
  1961. X *                 in do_dir since expand will return the full file info
  1962. X *                 appended to the file name. Set by formatfile().
  1963. X *                 eg. fullfilename'\0'rwed  NNNNNN NNNN  DD-MMM-YY HH:MM:SS
  1964. X *
  1965. X *                 Caller must call free_expand when done with the array.
  1966. X *
  1967. X * base             bname =       ename =
  1968. X * ------           -------       -------
  1969. X *  "*"               ""            "*"
  1970. X *  "!*.info"         ""            "*.info" (wild_exclude set)
  1971. X *  "su*d/*"          ""            "*"      (tail set)
  1972. X *  "file.*"          ""            "file.*"
  1973. X *  "df0:c/*"         "df0:c"       "*"
  1974. X *  ""                ""            "*"
  1975. X *  "df0:.../*"       "df0:"        "*"      (recur set)
  1976. X *  "df0:sub/.../*"   "df0:sub"     "*"      (recur set)
  1977. X *
  1978. X * ---the above base would be provided by execom.c or do_dir().
  1979. X * ---the below base would only be called from do_dir().
  1980. X *
  1981. X *  "file.c"          "file.c"      ""       if (dp == 0) fail else get file.c
  1982. X *  "df0:"            "df0:"        "*"
  1983. X *  "file/file"       "file/file"   ""       (dp == 0) so fail
  1984. X *  "df0:.../"        "df0:"        "*"      (recur set)
  1985. X *
  1986. X */
  1987. X
  1988. X
  1989. Xchar **
  1990. Xexpand(base, pac)
  1991. Xchar *base;
  1992. Xint *pac;
  1993. X{
  1994. X   register char *ptr;
  1995. X   char **eav = (char **)malloc(sizeof(char *) * (2));
  1996. X   short eleft, eac;
  1997. X   char *name;
  1998. X   char *svfile();
  1999. X   char *bname, *ename, *tail;
  2000. X   int stat, recur, scr, bl;
  2001. X   register struct DPTR *dp;
  2002. X
  2003. X   *pac = recur = eleft = eac = 0;
  2004. X
  2005. X   base = strcpy(malloc(strlen(base)+1), base);
  2006. X   for (ptr = base; *ptr && *ptr != '?' && *ptr != '*'; ++ptr);
  2007. X
  2008. X   if (!*ptr)   /* no wild cards */
  2009. X      --ptr;
  2010. X   else
  2011. X      for (; ptr >= base && !(*ptr == '/' || *ptr == ':'); --ptr);
  2012. X
  2013. X   if (ptr < base) {
  2014. X      bname = strcpy (malloc(1), "");
  2015. X   } else {
  2016. X      scr = ptr[1];
  2017. X      ptr[1] = '\0';
  2018. X      if (!strcmp(ptr-3,".../")) {
  2019. X         recur = 1;
  2020. X         *(ptr-3) = '\0';
  2021. X      }
  2022. X      bname = strcpy (malloc(strlen(base)+2), base);
  2023. X      ptr[1] = scr;
  2024. X   }
  2025. X   bl = strlen(bname);
  2026. X   ename = ++ptr;
  2027. X   for (; *ptr && *ptr != '/'; ++ptr);
  2028. X   scr = *ptr;
  2029. X   *ptr = '\0';
  2030. X   if (scr) ++ptr;
  2031. X   tail = ptr;
  2032. X
  2033. X   if ((dp = dopen (bname, &stat)) == NULL || (stat == 0 && *ename)) {
  2034. X      free (bname);
  2035. X      free (base);
  2036. X      free (eav);
  2037. X      return (NULL);
  2038. X   }
  2039. X
  2040. X   if (!stat) {                /* eg. 'dir file' */
  2041. X      char *p,*s;
  2042. X      for(s = p = bname; *p; ++p) if (*p == '/' || *p == ':') s = p;
  2043. X      if (s != bname) ++s;
  2044. X      *s ='\0';
  2045. X      eav[eac++] = svfile(bname,dp->fib->fib_FileName,dp->fib);
  2046. X      goto done;
  2047. X   }
  2048. X   if (!*ename) ename = "*";    /* eg. dir df0: */
  2049. X   if (*bname && bname[bl-1] != ':' && bname[bl-1] != '/') { /* dir df0:c */
  2050. X      bname[bl] = '/';
  2051. X      bname[++bl] = '\0';
  2052. X   }
  2053. X   while ((dnext (dp, &name, &stat)) && !breakcheck()) {
  2054. X        int match = compare_ok(ename,name);
  2055. X      if (match && !(!recur && *tail)) {
  2056. X         if (eleft < 2) {
  2057. X               char **scrav = (char **)malloc(sizeof(char *) * (eac + 10));
  2058. X               movmem (eav, scrav, (eac + 1) << 2);
  2059. X               free (eav);
  2060. X               eav = scrav;
  2061. X               eleft = 10;
  2062. X         }
  2063. X         eav[eac++] = svfile(bname,name,dp->fib);
  2064. X         --eleft;
  2065. X      }
  2066. X      if ((*tail && match) || recur) {
  2067. X         int alt_ac;
  2068. X         char *search, **alt_av, **scrav;
  2069. X         BPTR lock;
  2070. X
  2071. X         if (!stat)           /* expect more dirs, but this not a dir */
  2072. X            continue;
  2073. X         lock = CurrentDir (dp->lock);
  2074. X         search = malloc(strlen(ename)+strlen(name)+strlen(tail)+5);
  2075. X         strcpy (search, name);
  2076. X         strcat (search, "/");
  2077. X         if (recur) {
  2078. X            strcat(search, ".../");
  2079. X            strcat(search, ename);
  2080. X         }
  2081. X         strcat (search, tail);
  2082. X         scrav = alt_av = expand (search, &alt_ac);
  2083. X         /* free(search); */
  2084. X         CurrentDir (lock);
  2085. X         if (scrav) {
  2086. X            while (*scrav) {
  2087. X               int l;
  2088. X               if (eleft < 2) {
  2089. X                  char **scrav = (char **)malloc(sizeof(char *) * (eac + 10));
  2090. X                  movmem (eav, scrav, (eac + 1) << 2);
  2091. X                  free (eav);
  2092. X                  eav = scrav;
  2093. X                  eleft = 10;
  2094. X               }
  2095. X
  2096. X               l = strlen(*scrav);
  2097. X               scrav[0][l] = ' ';
  2098. X               eav[eac] = malloc(bl+l+45);
  2099. X               strcpy(eav[eac], bname);
  2100. X               strcat(eav[eac], *scrav);
  2101. X               eav[eac][l+bl] = '\0';
  2102. X
  2103. X               free (*scrav);
  2104. X               ++scrav;
  2105. X               --eleft, ++eac;
  2106. X            }
  2107. X            free (alt_av);
  2108. X         }
  2109. X      }
  2110. X   }
  2111. Xdone:
  2112. X   dclose (dp);
  2113. X   *pac = eac;
  2114. X   eav[eac] = NULL;
  2115. X   free (bname);
  2116. X   free (base);
  2117. X   if (eac) {
  2118. X      return (eav);
  2119. X   }
  2120. X   free (eav);
  2121. X   return (NULL);
  2122. X}
  2123. X
  2124. X/*
  2125. X * Compare a wild card name with a normal name
  2126. X */
  2127. X
  2128. X#define MAXB   8
  2129. X
  2130. Xcompare_ok(wild, name)
  2131. Xchar *wild, *name;
  2132. X{
  2133. Xregister char *w = wild;
  2134. Xregister char *n = name;
  2135. Xchar *back0[MAXB], *back1[MAXB];
  2136. Xint bi=0, queryflag;
  2137. X
  2138. Xif (*w=='!') return !compare_ok(wild+1,name);
  2139. Xif (queryflag=(*w=='&')) w++;
  2140. Xwhile (*n || *w) {
  2141. X   switch (*w) {
  2142. X      case '*':
  2143. X       if (bi==MAXB) { printf(stderr,"Too many levels of '*'\n"); return 0; }
  2144. X       back0[bi] = w;
  2145. X       back1[bi] = n;
  2146. X       ++bi;
  2147. X       ++w;
  2148. X       continue;
  2149. Xgoback:
  2150. X       --bi;
  2151. X       while (bi >= 0 && *back1[bi] == '\0') --bi;
  2152. X       if (bi < 0) return 0;
  2153. X       w = back0[bi] + 1;
  2154. X       n = ++back1[bi];
  2155. X       ++bi;
  2156. X       continue;
  2157. X      case '?':
  2158. X       if (!*n) goto goback;
  2159. X       break;
  2160. X      default:
  2161. X       if (Toupper(*n)!=Toupper(*w)) goto goback;
  2162. X       break;
  2163. X      }
  2164. X   if (*n) ++n;
  2165. X   if (*w) ++w;
  2166. X   }
  2167. Xif (queryflag) {
  2168. X    char in[256];
  2169. X    printf("Select \23337m%-16s\2330m [y/n] ? ",name);
  2170. X    gets(in);
  2171. X    return (Toupper(*in)=='Y');
  2172. X    }
  2173. Xreturn 1;
  2174. X}
  2175. X
  2176. Xchar *svfile(s1,s2,fib)
  2177. Xchar *s1,*s2;
  2178. XFIB *fib;
  2179. X{
  2180. Xchar *p = malloc (strlen(s1)+strlen(s2)+45);
  2181. Xstrcpy(p, s1);
  2182. Xstrcat(p, s2);
  2183. Xformatfile(p,fib);
  2184. Xreturn p;
  2185. X}
  2186. X
  2187. X/* will have either of these formats:
  2188. X *
  2189. X *    fullfilename'\0'hsparwed   <Dir>       DD-MMM-YY HH:MM:SS\n'\0'
  2190. X *    fullfilename'\0'hsparwed  NNNNNN NNNN  DD-MMM-YY HH:MM:SS\n'\0'
  2191. X *                              1111111111222222222233333333334 4  4
  2192. X *                    01234567890123456789012345678901234567890 1  2
  2193. X */
  2194. Xformatfile(str,fib)
  2195. Xchar *str;
  2196. XFIB *fib;
  2197. X{
  2198. Xchar *dates();
  2199. Xint i;
  2200. Xwhile(*str++);
  2201. Xfor (i=7; i>=0; i--)
  2202. X    *str++ = ((fib->fib_Protection & (1L<<i)) ? "hspa----" : "----rwed")[7-i];
  2203. Xif (fib->fib_DirEntryType < 0)
  2204. X  sprintf(str,"  %6ld %4ld  ", (long)fib->fib_Size, (long)fib->fib_NumBlocks);
  2205. Xelse strcpy(str,"   <Dir>       ");
  2206. Xstrcat(str,dates(&fib->fib_Date));
  2207. X}
  2208. X
  2209. X/* Sort routines */
  2210. X
  2211. Xlong cmp(s1, s2)
  2212. Xchar **s1, **s2;
  2213. X{
  2214. Xreturn (long)Strcmp(*s1, *s2);
  2215. X}
  2216. X
  2217. XCmp() {
  2218. X#asm
  2219. X    public    _geta4
  2220. X    movem.l    d2-d3/a4/a6,-(sp)
  2221. X    movem.l    a0/a1,-(sp)
  2222. X    bsr    _geta4
  2223. X    bsr    _cmp
  2224. X    addq.l    #8,sp
  2225. X    movem.l    (sp)+,d2-d3/a4/a6
  2226. X#endasm
  2227. X}
  2228. X
  2229. XQuickSort(av, n)
  2230. Xchar *av[];
  2231. Xint n;
  2232. X{
  2233. XQSort(av, (long)n, 4L, Cmp);
  2234. X}
  2235. SHAR_EOF
  2236. echo "End of archive 2 (of 2)"
  2237. # if you want to concatenate archives, remove anything after this line
  2238. exit
  2239.